home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / pc / SNNSV32.ZIP / SNNSv3.2 / xgui / sources / o_graph.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-04-25  |  33.5 KB  |  1,024 lines
  1. /*****************************************************************************
  2.   FILE           : o_graph.c
  3.   SHORTNAME      : o_graph.c
  4.   SNNS VERSION   : 3.2
  5.  
  6.   PURPOSE        : Contains all functions to run GRAPH.
  7.   NOTES          : You may wonder why all functions have the praefix "o_". 
  8.            That is easy to explaine: The original name of the progam 
  9.            was oszi.c but we had to change the name because it was 
  10.            not English enough.
  11.                     Small parts of graph.c are in the programs ui_remoteP.c 
  12.            and ui_fileP.c
  13.  
  14.   AUTHOR         : Markus Heuttel and Michael Schmalzl
  15.   DATE           : 3.4.1992
  16.  
  17.   CHANGED BY     :
  18.   IDENTIFICATION : @(#)o_graph.c    1.15 3/30/94
  19.   SCCS VERSION   : 1.15
  20.   LAST CHANGE    : 3/30/94
  21.  
  22.              Copyright (c) 1990-1994  SNNS Group, IPVR, Univ. Stuttgart, FRG
  23.              
  24. ******************************************************************************/
  25.  
  26.  
  27. #include <stdio.h>
  28. #include <malloc.h>
  29.  
  30. #include <X11/Xlib.h>
  31. #include <X11/Xutil.h>
  32. #include <X11/Xos.h>
  33. #include <X11/cursorfont.h>
  34. #include <X11/Intrinsic.h>
  35. #include <X11/StringDefs.h>
  36. #include <X11/Shell.h>
  37. #include <X11/Xaw/Box.h>
  38. #include <X11/Xaw/Simple.h>
  39. #include <X11/Xaw/Grip.h>
  40. #include <X11/Xaw/Form.h>
  41. #include <X11/Xaw/SmeBSB.h>
  42. #include <X11/Xaw/SmeLine.h>
  43. #include <X11/Xaw/Viewport.h>
  44. #include <X11/Xaw/Label.h>
  45. #include <X11/Xaw/Toggle.h>
  46. #include <X11/Xaw/Command.h>
  47. #include <X11/Xaw/Cardinals.h>
  48. #include <X11/Xaw/AsciiText.h>
  49. #include <X11/Xaw/Scrollbar.h>
  50.  
  51. #include "ui.h"
  52. #include "ui_xWidgets.h"
  53. #include "ui_textP.h"
  54. #include "ui_main.h"
  55. #include "ui_mainP.h"
  56.  
  57.  
  58. #include "done.xbm"
  59. #include "clear.xbm"
  60. #include "prev.xbm"
  61. #include "next.xbm"
  62.  
  63. #include "o_graph.ph"
  64.  
  65.  
  66.     /***************** Begin: Performance Functions *********************/
  67.  
  68.  
  69. /*****************************************************************************
  70.   FUNCTION : o_createOszi
  71.  
  72.   PURPOSE  : creates the  window GRAPH
  73.   RETURNS  : void
  74.   NOTES    :
  75.  
  76.   UPDATE   : 20.12.1991
  77. ******************************************************************************/
  78.  
  79. void o_createOszi (void)
  80.  
  81. {
  82.  Widget       form,w1,w2;
  83.  Widget       Done_oszi, clear_oszi;
  84.  Arg          arg[5];
  85.  Cardinal     n;
  86.  char         buf[40];
  87.  unsigned long foreground,background;
  88.  int          curr_unit,test_unit,
  89.               count_unit = 0;
  90.  
  91.  
  92.  /* test whether there are output units defined. Since no error can be 
  93.     computed in the opposit case, the graph tool can not be used */
  94.  curr_unit  = krui_getCurrentUnit();
  95.  test_unit  = krui_getFirstUnit();
  96.  do{
  97.      if((n=krui_getUnitTType(test_unit)) == 2) count_unit = 1;
  98.  }while((test_unit  = krui_getNextUnit()) && (count_unit == 0));
  99.  curr_unit  = krui_setCurrentUnit(curr_unit);
  100.  
  101.  if(count_unit == 0){
  102.     ui_confirmOk("No Output units defined!\nAn error can neither be\ncomputed nor displayed!");
  103.    return;
  104.  }
  105.  
  106.  
  107.  if(!o_open) {
  108.    o_open = 1; 
  109.    o_init();
  110.     
  111.    sprintf (buf, "graph");
  112.    n = 0;  
  113.  
  114.    XtSetArg(arg[n],XtNminHeight,200); n++;
  115.    XtSetArg(arg[n],XtNminWidth,400); n++;  
  116.    XtSetArg(arg[n],XtNheight,o_WindowHeight+29); n++;
  117.    XtSetArg(arg[n],XtNwidth,o_WindowWidth+10); n++;
  118.  
  119.    o_displayMainWidget = XtCreatePopupShell (buf, topLevelShellWidgetClass, ui_toplevel, arg, n); 
  120.    n = 0;  
  121.    form = XtCreateManagedWidget ("form", formWidgetClass, o_displayMainWidget, arg, n);
  122.  
  123.     Done_oszi = o_xCreateButtonItem ("Done",form,NULL,NULL);
  124.        XtAddCallback(Done_oszi,XtNcallback,(XtCallbackProc) o_DoneProc,NULL);
  125.  
  126.     clear_oszi = o_xCreateButtonItem ("Clear",form,Done_oszi,NULL);
  127.        XtAddCallback(clear_oszi,XtNcallback,(XtCallbackProc) o_clearProc,NULL);
  128.  
  129.     w1 = ui_xCreateLabelItem ("Scale X: ",form,8*8,clear_oszi,NULL); 
  130.     w2 = o_xCreateButtonItem ("prev",form,w1,NULL);
  131.       XtAddCallback(w2,XtNcallback,(XtCallbackProc) o_XForwardProc,NULL);
  132.     w1 = o_xCreateButtonItem ("next",form,w2,NULL);
  133.       XtAddCallback(w1,XtNcallback,(XtCallbackProc) o_XBackProc,NULL);
  134.  
  135.     w2 = ui_xCreateLabelItem ("  Scale Y: ",form,10*8,w1,NULL); 
  136.     w1 = o_xCreateButtonItem ("prev",form,w2,NULL); 
  137.       XtAddCallback(w1,XtNcallback,(XtCallbackProc) o_YBackProc,NULL);
  138.     w2 = o_xCreateButtonItem ("next",form,w1,NULL);
  139.       XtAddCallback(w2,XtNcallback,(XtCallbackProc) o_YForwardProc,NULL);
  140.  
  141.     o_DisplayWidget = o_xCreateScreenItem("screen",form,o_WindowWidth,o_WindowHeight,NULL,Done_oszi);
  142.        XtAddEventHandler(o_DisplayWidget,StructureNotifyMask | ExposureMask, 
  143.         FALSE,(XtEventHandler) o_eventProc,o_display);
  144.  
  145.     ui_checkWindowPosition(o_displayMainWidget);
  146.     XtPopup (o_displayMainWidget, XtGrabNone);
  147.  
  148.     o_display = XtDisplay (o_DisplayWidget); 
  149.     o_window = XtWindow (o_DisplayWidget);
  150.     o_fontStruct = XLoadQueryFont(o_display, "6x12");
  151.  
  152.     o_gc = XCreateGC (o_display, o_window, ZERO, NULL);
  153.     XSetFont(o_display,o_gc,(*o_fontStruct).fid);
  154.     o_screen = DefaultScreen (o_display);
  155.  
  156.     o_depth = DisplayPlanes(o_display,o_screen);
  157.  
  158.     background = WhitePixel (o_display, o_screen);
  159.     foreground = BlackPixel (o_display, o_screen); 
  160.    /* XSetWindowBackground(o_display,o_window,background); */
  161.     XSetBackground (o_display, o_gc, background);
  162.     XSetForeground (o_display, o_gc, foreground); 
  163.  
  164.     XSetGraphicsExposures(o_display,o_gc,0);
  165.  
  166.     o_Pixmap = XCreatePixmap(o_display,o_window,(unsigned int) o_PixmapWidth, 
  167.     (unsigned int) o_PixmapHeight, (unsigned int) o_depth);
  168.     o_ClearPixmap(o_display,o_Pixmap,o_gc,o_screen,0,0,o_PixmapWidth,o_PixmapHeight); 
  169.     XClearArea(o_display,o_window,o_OsziXPos,o_OsziYPos, 
  170.     (unsigned int) o_OsziWidth-1, (unsigned int) o_OsziHeight,1);
  171.    } 
  172. }
  173.  
  174.  
  175. /*****************************************************************************
  176.   FUNCTION : o_eventProc
  177.  
  178.   PURPOSE  : Manages the events (resize and exposure)
  179.   RETURNS  : void
  180.   NOTES    :
  181.  
  182.   UPDATE   : 3.4.1992
  183. ******************************************************************************/
  184.  
  185. static void o_eventProc (Widget w, Display *display, XEvent *event)
  186.  
  187. {
  188.  switch (event->type) {
  189.    case Expose: {
  190.      if(event->xexpose.count == 0) {
  191.          XCopyArea(o_display,o_Pixmap,o_window,o_gc,0,0,(unsigned int) o_OsziWidth, (unsigned int) o_OsziHeight,o_OsziXPos,o_OsziYPos);
  192.          XDrawRectangle(o_display,o_window,o_gc,o_OsziFrameXPos,o_OsziFrameYPos, (unsigned int) o_OsziWidth+1, (unsigned int) o_OsziHeight);
  193.          o_ScaleY(o_display,o_window,o_gc);
  194.          o_ScaleX(o_display,o_window,o_gc);
  195.      }
  196.      break;
  197.    }
  198.    case ConfigureNotify: {
  199.      o_ResizeOszi(event->xconfigure.width,event->xconfigure.height);
  200.      break;
  201.    }
  202.  }     
  203. }
  204.  
  205.  
  206. /*****************************************************************************
  207.   FUNCTION : o_clearProc
  208.  
  209.   PURPOSE  : callback function of the clear-buttom. 
  210.              Clears all curves of the display.
  211.   RETURNS  : void
  212.   NOTES    :
  213.  
  214.   UPDATE   : 3.4.1992
  215. ******************************************************************************/
  216.  
  217. static void o_clearProc (void)
  218.  
  219. {
  220.  if(o_PressPossible){
  221.    o_ClearPixmap(o_display,o_Pixmap,o_gc,o_screen,0,0,o_PixmapWidth,o_PixmapHeight);
  222.    XClearArea(o_display,o_window,o_OsziXPos,o_OsziYPos,(unsigned int) o_OsziWidth,(unsigned int) o_OsziHeight-1,1);
  223.    o_ClearCurves();
  224.    o_LearnStepCount = 0;
  225.  }
  226. }
  227.  
  228.  
  229. /*****************************************************************************
  230.   FUNCTION : o_DoneProc
  231.  
  232.   PURPOSE  : callback function of the done-buttom. You are leaving bignet.A
  233.   RETURNS  : void
  234.   NOTES    :
  235.  
  236.   UPDATE   : 3.4.1992
  237. ******************************************************************************/
  238.  
  239. static void o_DoneProc (void)
  240.  
  241. {
  242.  if(o_PressPossible){
  243.    o_clearProc();
  244.    XtDestroyWidget(o_displayMainWidget);
  245.    o_open = 0;
  246.  }
  247. }
  248.  
  249.  
  250. /*****************************************************************************
  251.   FUNCTION : o_xCreateButtonItem
  252.  
  253.   PURPOSE  : create a command widget
  254.   RETURNS  : Widget
  255.   NOTES    :
  256.  
  257.   UPDATE   : 3.4.1992
  258. ******************************************************************************/
  259.  
  260. static Widget o_xCreateButtonItem (char *name, Widget parent, Widget left, Widget top)
  261.  
  262. {
  263.     int n;
  264.     Widget   w;
  265.     Arg      arg[15];
  266.     
  267.     n = 0;
  268.  
  269.     if (strcmp (name, "Done") == 0)
  270.       {  
  271.         XtSetArg(arg[n], XtNbitmap, 
  272.                   (Pixmap) XCreateBitmapFromData (ui_display,
  273.                    XDefaultRootWindow (ui_display), 
  274.                    done_bits, done_width, done_height)); n++;
  275.       } 
  276.  
  277.     if (strcmp (name, "Clear") == 0)
  278.       {  
  279.         XtSetArg(arg[n], XtNbitmap, 
  280.                   (Pixmap) XCreateBitmapFromData (ui_display,
  281.                    XDefaultRootWindow (ui_display), 
  282.                    clear_bits, clear_width, clear_height)); n++;
  283.       } 
  284.  
  285.     if (strcmp (name, "prev") == 0)
  286.       {  
  287.         XtSetArg(arg[n], XtNbitmap, 
  288.                   (Pixmap) XCreateBitmapFromData (ui_display,
  289.                    XDefaultRootWindow (ui_display), 
  290.                    prev_bits, prev_width, prev_height)); n++;
  291.       } 
  292.  
  293.     if (strcmp (name, "next") == 0)
  294.       {  
  295.         XtSetArg(arg[n], XtNbitmap, 
  296.                   (Pixmap) XCreateBitmapFromData (ui_display,
  297.                    XDefaultRootWindow (ui_display), 
  298.                    next_bits, next_width, next_height)); n++;
  299.       } 
  300.  
  301.     XtSetArg(arg[n], XtNborderWidth, 0); n++;
  302.     XtSetArg(arg[n], XtNinternalHeight, 1); n++;
  303.     XtSetArg(arg[n], XtNinternalWidth , 1); n++;
  304.  
  305.     XtSetArg(arg[n], XtNfromVert , top);  n++;
  306.     XtSetArg(arg[n], XtNfromHoriz, left);  n++;
  307.     XtSetArg(arg[n], XtNleft  , XtChainLeft); n++;
  308.     XtSetArg(arg[n], XtNright , XtChainLeft); n++;
  309.     XtSetArg(arg[n], XtNtop   , XtChainTop); n++;
  310.     XtSetArg(arg[n], XtNbottom, XtChainTop); n++;
  311.  
  312.     w = XtCreateManagedWidget(name, commandWidgetClass, parent, arg, 
  313.     (unsigned int) n);
  314.     return(w);
  315. }
  316.  
  317.  
  318. /*****************************************************************************
  319.   FUNCTION : o_xCreateScreenItem
  320.  
  321.   PURPOSE  : Creates the widget on which the curves are drawn.
  322.   RETURNS  : Widget
  323.   NOTES    :
  324.  
  325.   UPDATE   : 3.4.1992
  326. ******************************************************************************/
  327.  
  328. static Widget   o_xCreateScreenItem (char *name, Widget parent, Dimension width, 
  329.     Dimension height, Widget left, Widget top)
  330.  
  331. { 
  332.     Cardinal n;
  333.     Widget   w;
  334.     Arg      args[15];
  335.  
  336.     n = 0;
  337.     XtSetArg(args[n], XtNheight,height); n++;
  338.     XtSetArg(args[n], XtNwidth,width); n++;
  339.     XtSetArg(args[n], XtNfromVert , top);  n++;
  340.  
  341.     XtSetArg(args[n], XtNleft  , XtChainLeft); n++;
  342.     XtSetArg(args[n], XtNright , XtChainRight); n++;
  343.     XtSetArg(args[n], XtNtop   , XtChainTop); n++;
  344.     XtSetArg(args[n], XtNbottom, XtChainBottom); n++;
  345.  
  346.    XtSetArg(args[n],XtNresizable,True); n++;
  347.  
  348.     w = XtCreateManagedWidget(name, formWidgetClass, parent, args, n);
  349.  
  350.     return(w);
  351. }
  352.  
  353.  
  354. /*****************************************************************************
  355.   FUNCTION : o_XBackProc
  356.  
  357.   PURPOSE  : callback function which changes the scala of the x-axis. The scala
  358.              is enlarged. (You press the right x-buttom)
  359.   RETURNS  : void
  360.   NOTES    :
  361.  
  362.   UPDATE   : 3.4.1992
  363. ******************************************************************************/
  364.  
  365. static void o_XBackProc (void)
  366.  
  367. {
  368.  if(o_PressPossible){
  369.    o_XBack();
  370.  }
  371. }
  372.  
  373.  
  374. /*****************************************************************************
  375.   FUNCTION : o_XForwardProc
  376.  
  377.   PURPOSE  : callback function which changes the scala of the x-axis. The scala
  378.              is lessened. (You press the left x-buttom)
  379.   RETURNS  : void
  380.   NOTES    :
  381.  
  382.   UPDATE   : 3.4.1992
  383. ******************************************************************************/
  384.  
  385. static void o_XForwardProc (void)
  386.  
  387. {
  388.  if(o_PressPossible){
  389.    o_XForward();
  390.  }
  391. }
  392.  
  393.  
  394. /*****************************************************************************
  395.   FUNCTION : o_YBackProc
  396.  
  397.   PURPOSE  : callback function which changes the scala of the y-axis. The scala
  398.              is lessened. (You press the left y-buttom)
  399.   RETURNS  : void
  400.   NOTES    : That's just the other way round as o_XBackProc!
  401.  
  402.   UPDATE   : 3.4.1992
  403. ******************************************************************************/
  404.  
  405. static void o_YBackProc (void)
  406.  
  407. {
  408.  if(o_PressPossible){
  409.    o_YBack();
  410.  }
  411. }
  412.  
  413.  
  414. /*****************************************************************************
  415.   FUNCTION : o_YForwardProc
  416.  
  417.   PURPOSE  : callback function which changes the scala of the y-axis. The scala
  418.              is enlarged. (You press the right y-buttom)
  419.   RETURNS  : void
  420.   NOTES    : That's just the other way round as o_XForwardProc!
  421.  
  422.   UPDATE   : 3.4.1992
  423. ******************************************************************************/
  424.  
  425. static void o_YForwardProc (void)
  426.  
  427. {
  428.  if(o_PressPossible){
  429.    o_YForward();
  430.  }
  431. }
  432.  
  433.  
  434.     /***************** End: Performance Functions *********************/
  435.  
  436.  
  437. /*****************************************************************************
  438.   FUNCTION : o_init
  439.  
  440.   PURPOSE  : Initializes all variables of GRAPH. 
  441.   RETURNS  : void
  442.   NOTES    :
  443.  
  444.   UPDATE   : 20.12.1991
  445. ******************************************************************************/
  446.  
  447. static void o_init (void)
  448.  
  449. {
  450.  int i;
  451.  
  452.  o_WindowWidth = 490;
  453.  o_WindowHeight = 250;
  454.  
  455.  o_LearnStepCount = 0;
  456.  o_YCounter = 3;
  457.  o_XCounter = 9;
  458.  
  459.  o_PixelsOfOneLearningStep = o_XScaleValues[o_XCounter].ScreenEinheit/o_XScaleValues[o_XCounter].Einheit; 
  460.  o_PixelsOfOneLearningStep = ((o_PixelsOfOneLearningStep == 0) ? (1) : (o_PixelsOfOneLearningStep));
  461.  o_LearningStepsOfOnePixel = o_XScaleValues[o_XCounter].Einheit/o_XScaleValues[o_XCounter].ScreenEinheit;
  462.  o_LearningStepsOfOnePixel = ((o_LearningStepsOfOnePixel == 1) ? (0) : (o_LearningStepsOfOnePixel));
  463.  
  464.  o_AbsoluteScale = (float)o_YScaleValues[o_YCounter].ScreenEinheit/(float)o_YScaleValues[o_YCounter].Einheit;
  465.  
  466.  o_RightOffset      = o_PixelsOfOneLearningStep;
  467.  o_OsziXPos         = o_SpaceLeft;
  468.  o_OsziYPos         = o_SpaceAbove;
  469.  o_OsziHeight       = 200;  
  470.  o_OsziWidth        = 400; 
  471.  o_PixmapWidth      = o_OsziWidth+o_RightOffset;
  472.  o_PixmapHeight     = o_OsziHeight;
  473.  o_OsziFrameXPos   = o_OsziXPos - 1; 
  474.  o_OsziFrameYPos   = o_OsziYPos - 1;
  475.  o_OsziFrameWidth  = o_OsziWidth + 2;
  476.  o_OsziFrameHeight = o_OsziHeight + 2;
  477.  o_MaxYDrawPos      = o_OsziHeight-1;
  478.  
  479.  o_CurveNo = 0;
  480.  for(i=0;i<MAX_CURVE_NO;i++) {
  481.    o_CurveLengths[i] = -1;
  482.  }
  483.  o_InitCurve();
  484. }
  485.  
  486.  
  487. /*****************************************************************************
  488.   FUNCTION : o_InitCurve
  489.  
  490.   PURPOSE  : Allocates space for a new curve.
  491.   RETURNS  : void
  492.   NOTES    :
  493.  
  494.   UPDATE   : 20.12.1991
  495. ******************************************************************************/
  496.  
  497. void o_InitCurve (void)
  498.  
  499. {
  500.  char buf[80];
  501.  
  502.  if(o_open && (o_CurveLengths[o_CurveNo] != 0)) {
  503.    if(o_CurveLengths[o_CurveNo] == -1) {
  504.      o_DrawAllowed = 1;
  505.      o_MaxCurveLengths = (int)(o_OsziWidth/o_PixelsOfOneLearningStep);
  506.      o_Curve1[o_CurveNo] = (XPoint *)malloc(sizeof(XPoint)*o_MaxCurveLengths);
  507.      o_Curve2[o_CurveNo]   = (MPoint *)malloc(sizeof(MPoint)*o_MaxCurveLengths);
  508.      o_CurveLengths[o_CurveNo] = 0;
  509.      o_Curve1[o_CurveNo][0].x = -1;
  510.      o_Curve1[o_CurveNo][0].y = -1;
  511.      o_Curve2[o_CurveNo][0].x =  0;
  512.      o_Curve2[o_CurveNo][0].y =  0;
  513.    }
  514.    else {
  515.      o_DrawAllowed = 0;
  516.      sprintf(buf,"The max no of curves you can draw is %d",MAX_CURVE_NO);
  517.      ui_tw_errorMessage(buf);
  518.    }
  519.  }
  520. }
  521.  
  522.  
  523. /*****************************************************************************
  524.   FUNCTION : o_ClearCurves
  525.  
  526.   PURPOSE  : Deletes all curves. (The curves vanish from display and the 
  527.              storage is set free.
  528.   RETURNS  : void
  529.   NOTES    :
  530.  
  531.   UPDATE   : 3.4.1992
  532. ******************************************************************************/
  533.  
  534. static void o_ClearCurves (void)
  535.  
  536. {
  537.  /* Old Style: for(o_CurveNo;o_CurveNo>=0;o_CurveNo--) */
  538.  for(;o_CurveNo>=0;o_CurveNo--) 
  539.    {
  540.    o_CurveLengths[o_CurveNo]= -1;
  541.    free(o_Curve1[o_CurveNo]);
  542.    free(o_Curve2[o_CurveNo]);
  543.  }
  544.  o_CurveNo = 0;
  545.  o_InitCurve();
  546. }
  547.  
  548.  
  549. /*****************************************************************************
  550.   FUNCTION : o_ResizeOszi
  551.  
  552.   PURPOSE  : This function is called when there is a risize event by the 
  553.              X-server. The variables are initialized with their new values,
  554.              the storage for the current curve (only for this one) is 
  555.          reallocated and the curves are drawn again.
  556.   RETURNS  : void
  557.   NOTES    :
  558.  
  559.   UPDATE   : 3.4.1992
  560. ******************************************************************************/
  561.  
  562. static void o_ResizeOszi (int box_width, int box_height)
  563.  
  564. {
  565.  int Length,UsedStorage,NeededStorage,FreeStorage,x;
  566.  int i,j;
  567.  
  568.  o_WindowWidth = box_width;
  569.  o_WindowHeight = box_height;
  570.  
  571.  o_PixelsOfOneLearningStep = o_XScaleValues[o_XCounter].ScreenEinheit/o_XScaleValues[o_XCounter].Einheit;
  572.  o_PixelsOfOneLearningStep = ((o_PixelsOfOneLearningStep == 0) ? (1) : (o_PixelsOfOneLearningStep));
  573.  o_LearningStepsOfOnePixel = o_XScaleValues[o_XCounter].Einheit/o_XScaleValues[o_XCounter].ScreenEinheit;
  574.  o_LearningStepsOfOnePixel = ((o_LearningStepsOfOnePixel == 1) ? (0) : (o_LearningStepsOfOnePixel));
  575.  
  576.  o_RightOffset      = o_PixelsOfOneLearningStep;
  577.  o_OsziHeight       = o_WindowHeight-o_SpaceAbove-o_SpaceBelow;  
  578.  o_OsziWidth        = o_WindowWidth-o_SpaceLeft-o_SpaceRight;
  579.  o_PixmapWidth      = o_OsziWidth+o_RightOffset;
  580.  o_PixmapHeight     = o_OsziHeight;
  581.  o_OsziFrameWidth   = o_OsziWidth + 2;
  582.  o_OsziFrameHeight  = o_OsziHeight + 2;
  583.  o_MaxYDrawPos      = o_OsziHeight-1;
  584.  
  585.  for(i=0;i<=o_CurveNo;i++) {
  586.    for(j=0;j<o_CurveLengths[i];j++) {
  587.      o_Curve1[i][j].y = (int) (o_MaxYDrawPos-(o_Curve2[i][j].y*o_AbsoluteScale));
  588.    }
  589.  }
  590.  
  591.  Length = ((o_CurveLengths[o_CurveNo]-1 == -1)?(0):(o_CurveLengths[o_CurveNo]-1)); 
  592.  x = ((o_Curve1[o_CurveNo][Length].x == -1)?(0):(o_Curve1[o_CurveNo][Length].x)); 
  593.  UsedStorage = o_CurveLengths[o_CurveNo];
  594.  FreeStorage = (int)((o_OsziWidth-x)/o_PixelsOfOneLearningStep);
  595.  NeededStorage = ((FreeStorage <= 0)?(0):(FreeStorage+UsedStorage));
  596.  
  597.  if(NeededStorage > UsedStorage) {
  598.    o_Curve1[o_CurveNo] = (XPoint *)realloc(o_Curve1[o_CurveNo],NeededStorage*sizeof(XPoint));
  599.    o_Curve2[o_CurveNo] = (MPoint *)realloc(o_Curve2[o_CurveNo],NeededStorage*sizeof(MPoint));
  600.    o_MaxCurveLengths = NeededStorage;
  601.  }
  602.  
  603.  XFreePixmap(o_display,o_Pixmap);
  604.  o_Pixmap = XCreatePixmap(o_display,o_window,(unsigned int) o_PixmapWidth, (unsigned int) o_PixmapHeight, (unsigned int) o_depth);
  605.  o_ClearPixmap(o_display,o_Pixmap,o_gc,o_screen,0,0,o_PixmapWidth,o_PixmapHeight); 
  606.  for(i=0;i<=o_CurveNo;i++) {
  607.    XDrawLines(o_display,o_Pixmap,o_gc,o_Curve1[i],o_CurveLengths[i],CoordModeOrigin);
  608.  }
  609.  XClearArea(o_display,o_window,0,0,(unsigned int) o_WindowWidth, (unsigned int) o_WindowHeight,0); 
  610.  XCopyArea(o_display,o_Pixmap,o_window,o_gc,0,0,(unsigned int) o_OsziWidth,(unsigned int) o_OsziHeight,o_OsziXPos,o_OsziYPos);
  611.  XDrawRectangle(o_display,o_window,o_gc,o_OsziFrameXPos,o_OsziFrameYPos,
  612.     (unsigned int) o_OsziWidth+1, (unsigned int) o_OsziHeight);
  613.  o_ScaleY(o_display,o_window,o_gc); 
  614.  o_ScaleX(o_display,o_window,o_gc); 
  615. }
  616.  
  617.  
  618. /*****************************************************************************
  619.   FUNCTION : o_XScaleCurve
  620.  
  621.   PURPOSE  : After the size of the x-scala has changed, the pixel position
  622.              of the x-values must be calculated again. (Remember: the array
  623.              Curve1 contains the pixel positions of the curves, while the
  624.              array Curve2 contains the number of learnsteps as x-value and
  625.              the learn-error as y-value.)
  626.   RETURNS  : void
  627.   NOTES    : Is called by o_XBack and by o_XForward.
  628.  
  629.   UPDATE   : 3.4.1992
  630. ******************************************************************************/
  631.  
  632. static void o_XScaleCurve (void)
  633.  
  634. {
  635.  int i,j,tmp_Curve1_x;
  636.  double PixelsOfOneLearningStep;
  637.    
  638.  for(i=0;i<=o_CurveNo;i++) {
  639.    PixelsOfOneLearningStep = o_XScaleValues[o_XCounter].ScreenEinheit/o_XScaleValues[o_XCounter].Einheit;
  640.    for(j=0;j<o_CurveLengths[i];j++) {
  641.      tmp_Curve1_x = o_Curve2[i][j].x*PixelsOfOneLearningStep-1;
  642.      /* 
  643.         This is necessery to prevent too large values for o_Curve1[i][j].x, which is of the type "short" (XPoint),
  644.         when scaling downward. 
  645.      */ 
  646.      o_Curve1[i][j].x = (tmp_Curve1_x > 32767) ? (32767) : (tmp_Curve1_x);
  647.    }
  648.  }
  649. }
  650.  
  651.  
  652. /*****************************************************************************
  653.   FUNCTION : o_XBack
  654.  
  655.   PURPOSE  : The scala of the x-axis is enlarged. The variables have to be 
  656.              initialized with new values and the storage of the current curve 
  657.              (only for this one) has to be reallocated. Before drawing all 
  658.              visible curves, the function o_XScaleCurve() must be called.
  659.   RETURNS  : void
  660.   NOTES    :
  661.  
  662.   UPDATE   : 3.4.1992
  663. ******************************************************************************/
  664.  
  665. static void o_XBack (void)
  666.  
  667. {
  668.  int i,Length;
  669.  double PixelsOfOneLearningStep;
  670.  int UsedStorage,FreeStorage,NeededStorage;
  671.  
  672.  o_XCounter = (--o_XCounter < 0) ? (0) : (o_XCounter);
  673.  
  674.  o_PixelsOfOneLearningStep = PixelsOfOneLearningStep = o_XScaleValues[o_XCounter].ScreenEinheit/o_XScaleValues[o_XCounter].Einheit;
  675.  o_PixelsOfOneLearningStep = ((o_PixelsOfOneLearningStep == 0) ? (1) : (o_PixelsOfOneLearningStep));
  676.  o_LearningStepsOfOnePixel = o_XScaleValues[o_XCounter].Einheit/o_XScaleValues[o_XCounter].ScreenEinheit;
  677.  o_LearningStepsOfOnePixel = ((o_LearningStepsOfOnePixel == 1) ? (0) : (o_LearningStepsOfOnePixel));
  678.  
  679.  Length = (o_CurveLengths[o_CurveNo]-1 == -1)?(0):(o_CurveLengths[o_CurveNo]-1);
  680.  UsedStorage = o_CurveLengths[o_CurveNo];
  681.  FreeStorage = (int)((o_OsziWidth-(o_Curve2[o_CurveNo][Length].x*PixelsOfOneLearningStep-1))/o_PixelsOfOneLearningStep);
  682.  NeededStorage = ((FreeStorage <= 0)?(0):(FreeStorage+UsedStorage));
  683.  
  684.  if(NeededStorage>o_MaxCurveLengths){
  685.    o_Curve1[o_CurveNo] = (XPoint *)realloc(o_Curve1[o_CurveNo],NeededStorage*sizeof(XPoint));
  686.    o_Curve2[o_CurveNo] = (MPoint *)realloc(o_Curve2[o_CurveNo],NeededStorage*sizeof(MPoint));
  687.    o_MaxCurveLengths = NeededStorage;
  688.  }
  689.  o_XScaleCurve();
  690.  XClearArea(o_display,o_window,0,0,(unsigned int) o_WindowWidth,(unsigned int) o_WindowHeight,0); 
  691.  o_ScaleY(o_display,o_window,o_gc); 
  692.  o_ScaleX(o_display,o_window,o_gc); 
  693.  o_ClearPixmap(o_display,o_Pixmap,o_gc,o_screen,0,0,o_PixmapWidth,o_PixmapHeight); 
  694.  for(i=0;i<=o_CurveNo;i++) {
  695.    XDrawLines(o_display,o_Pixmap,o_gc,o_Curve1[i],o_CurveLengths[i],CoordModeOrigin);
  696.  } 
  697.  XCopyArea(o_display,o_Pixmap,o_window,o_gc,0,0,(unsigned int) o_OsziWidth,
  698.     (unsigned int) o_OsziHeight,o_OsziXPos,o_OsziYPos);
  699.  XDrawRectangle(o_display,o_window,o_gc,o_OsziFrameXPos,o_OsziFrameYPos,
  700.     (unsigned int) o_OsziWidth+1,(unsigned int) o_OsziHeight);
  701.  }
  702.  
  703.  
  704. /*****************************************************************************
  705.   FUNCTION : o_XForward
  706.  
  707.   PURPOSE  : The scala of the x-axis is lessened. The variables have to be 
  708.              initialized with new values and the storage of the current curve 
  709.              (only for this one) has to be reallocated. Before drawing all 
  710.              visible curves, the function o_XScaleCurve() must be called. 
  711.   RETURNS  : void
  712.   NOTES    :
  713.  
  714.   UPDATE   : 3.4.1992
  715. ******************************************************************************/
  716.  
  717. static void o_XForward (void)
  718.  
  719. {
  720.  int i,Length;
  721.  double PixelsOfOneLearningStep;
  722.  int UsedStorage,FreeStorage,NeededStorage;
  723.  
  724.  if(o_XCounter != 14){ 
  725.    o_XCounter++;
  726.  
  727.    o_PixelsOfOneLearningStep = PixelsOfOneLearningStep = o_XScaleValues[o_XCounter].ScreenEinheit/o_XScaleValues[o_XCounter].Einheit;
  728.    o_PixelsOfOneLearningStep = ((o_PixelsOfOneLearningStep == 0) ? (1) : (o_PixelsOfOneLearningStep));
  729.    o_LearningStepsOfOnePixel = o_XScaleValues[o_XCounter].Einheit/o_XScaleValues[o_XCounter].ScreenEinheit;
  730.    o_LearningStepsOfOnePixel = ((o_LearningStepsOfOnePixel == 1) ? (0) : (o_LearningStepsOfOnePixel));
  731.  
  732.    Length = (o_CurveLengths[o_CurveNo]-1 == -1)?(0):(o_CurveLengths[o_CurveNo]-1);
  733.  
  734.    UsedStorage = o_CurveLengths[o_CurveNo];
  735.    FreeStorage = (int)((o_OsziWidth-(o_Curve2[o_CurveNo][Length].x*PixelsOfOneLearningStep-1))/o_PixelsOfOneLearningStep);
  736.    NeededStorage = ((FreeStorage <= 0)?(0):(FreeStorage+UsedStorage));
  737.  
  738.    if(NeededStorage){
  739.      o_Curve1[o_CurveNo] = (XPoint *)realloc(o_Curve1[o_CurveNo],NeededStorage*sizeof(XPoint));
  740.      o_Curve2[o_CurveNo] = (MPoint *)realloc(o_Curve2[o_CurveNo],NeededStorage*sizeof(MPoint));
  741.      o_MaxCurveLengths = NeededStorage;
  742.    }
  743.    o_XScaleCurve();
  744.    XClearArea(o_display,o_window,0,0,(unsigned int) o_WindowWidth,(unsigned int) o_WindowHeight,0); 
  745.    o_ScaleY(o_display,o_window,o_gc); 
  746.    o_ScaleX(o_display,o_window,o_gc); 
  747.    o_ClearPixmap(o_display,o_Pixmap,o_gc,o_screen,0,0,o_PixmapWidth,o_PixmapHeight); 
  748.    for(i=0;i<=o_CurveNo;i++) {
  749.      XDrawLines(o_display,o_Pixmap,o_gc,o_Curve1[i],o_CurveLengths[i],CoordModeOrigin);
  750.    }
  751.    XCopyArea(o_display,o_Pixmap,o_window,o_gc,0,0,(unsigned int) o_OsziWidth,(unsigned int) o_OsziHeight,o_OsziXPos,o_OsziYPos);
  752.    XDrawRectangle(o_display,o_window,o_gc,o_OsziFrameXPos,o_OsziFrameYPos,
  753.     (unsigned int) o_OsziWidth+1,(unsigned int) o_OsziHeight);
  754.  }
  755. }
  756.  
  757.  
  758. /*****************************************************************************
  759.   FUNCTION : o_YScaleCurve
  760.  
  761.   PURPOSE  : After the size of the y-scala has changed, the pixel position
  762.              of the y-values must be calculated again. (Remember: the array
  763.              Curve1 contains the pixel positions of the curves, while the
  764.              array Curve2 contains the number of learnsteps as x-value and
  765.              the learn-error as y-value.)
  766.   RETURNS  : void
  767.   NOTES    : Is called by o_YForwardCurve() and o_YBack().
  768.  
  769.   UPDATE   : 3.4.1992
  770. ******************************************************************************/
  771.  
  772. static void o_YScaleCurve (void)
  773.  
  774. {
  775.  int i,j;
  776.    
  777.  for(i=0;i<=o_CurveNo;i++) {
  778.    for(j=0;j<o_CurveLengths[i];j++) {
  779.      o_Curve1[i][j].y = (int) (o_MaxYDrawPos-(o_Curve2[i][j].y*o_AbsoluteScale));
  780.    }
  781.  }
  782. }
  783.  
  784.  
  785. /*****************************************************************************
  786.   FUNCTION : o_YForward
  787.  
  788.   PURPOSE  : The scala of the y-axis is enlarged. The variables have to be 
  789.              initialized with new values and the storage of the current curve 
  790.              (only for this one) has to be reallocated. Before drawing all 
  791.              visible curves, the function o_YScaleCurve() must be called.
  792.   RETURNS  : void
  793.   NOTES    :
  794.  
  795.   UPDATE   : 3.4.1992
  796. ******************************************************************************/
  797.  
  798. static void o_YForward (void)
  799.  
  800. {
  801.  int i;
  802.  
  803.  o_YCounter = (++o_YCounter > 14) ? (14) : (o_YCounter);
  804.  
  805.  o_AbsoluteScale = (float)o_YScaleValues[o_YCounter].ScreenEinheit/(float)o_YScaleValues[o_YCounter].Einheit;
  806.  
  807.  o_YScaleCurve();
  808.  XClearArea(o_display,o_window,0,0,(unsigned int) o_WindowWidth,(unsigned int) o_WindowHeight,0);  
  809.  o_ScaleY(o_display,o_window,o_gc); 
  810.  o_ScaleX(o_display,o_window,o_gc);
  811.  o_ClearPixmap(o_display,o_Pixmap,o_gc,o_screen,0,0,o_PixmapWidth,o_PixmapHeight);
  812.  
  813.  for(i=0;i<=o_CurveNo;i++) {
  814.    XDrawLines(o_display,o_Pixmap,o_gc,o_Curve1[i],o_CurveLengths[i],CoordModeOrigin);
  815.  }
  816.  XCopyArea(o_display,o_Pixmap,o_window,o_gc,0,0,(unsigned int) o_OsziWidth, (unsigned int) o_OsziHeight,o_OsziXPos,o_OsziYPos);
  817.  XDrawRectangle(o_display,o_window,o_gc,o_OsziFrameXPos,o_OsziFrameYPos,(unsigned int) o_OsziWidth+1,(unsigned int) o_OsziHeight);
  818. }
  819.  
  820.  
  821. /*****************************************************************************
  822.   FUNCTION : o_YBack
  823.  
  824.   PURPOSE  : The scala of the y-axis is lessened. The variables have to be 
  825.              initialized with new values and the storage of the current curve 
  826.              (only for this one) has to be reallocated. Before drawing all 
  827.              visible curves, the function o_YScaleCurve() must be called.
  828.   RETURNS  : void
  829.   NOTES    :
  830.  
  831.   UPDATE   : 3.4.1992
  832. ******************************************************************************/
  833.  
  834. static void o_YBack (void)
  835.  
  836. {
  837.  int i;
  838.  
  839.  o_YCounter = (--o_YCounter < 0) ? (0) : (o_YCounter);
  840.  
  841.  o_AbsoluteScale = (float)o_YScaleValues[o_YCounter].ScreenEinheit/(float)o_YScaleValues[o_YCounter].Einheit;
  842.  
  843.  o_YScaleCurve();
  844.  XClearArea(o_display,o_window,0,0,(unsigned int) o_WindowWidth,(unsigned int) o_WindowHeight,0);  
  845.  o_ScaleY(o_display,o_window,o_gc); 
  846.  o_ScaleX(o_display,o_window,o_gc);
  847.  o_ClearPixmap(o_display,o_Pixmap,o_gc,o_screen,0,0,o_PixmapWidth,o_PixmapHeight);
  848.  
  849.  for(i=0;i<=o_CurveNo;i++) {
  850.    XDrawLines(o_display,o_Pixmap,o_gc,o_Curve1[i],o_CurveLengths[i],CoordModeOrigin);
  851.  }
  852.  XCopyArea(o_display,o_Pixmap,o_window,o_gc,0,0,(unsigned int) o_OsziWidth,(unsigned int) o_OsziHeight,o_OsziXPos,o_OsziYPos);
  853.  
  854.  XDrawRectangle(o_display,o_window,o_gc,o_OsziFrameXPos,o_OsziFrameYPos,(unsigned int) o_OsziWidth+1,(unsigned int) o_OsziHeight);
  855. }
  856.  
  857.  
  858. /*****************************************************************************
  859.   FUNCTION : o_draw 
  860.  
  861.   PURPOSE  : draws the current curve and updates the arrays Curve1 and Curve2.
  862.   RETURNS  : void
  863.   NOTES    :
  864.  
  865.   UPDATE   : 3.4.1992
  866. ******************************************************************************/
  867.  
  868. void o_draw (float net_error)
  869.  
  870. {
  871.  double PixelsOfOneLearningStep;
  872.  int error;
  873.  int Length = o_CurveLengths[o_CurveNo];
  874.  int OldX=o_Curve1[o_CurveNo][(Length-1==-1)?(0):(Length-1)].x;
  875.  int OldY=o_Curve1[o_CurveNo][(Length-1==-1)?(0):(Length-1)].y;
  876.  int NewX =  (OldX+o_PixelsOfOneLearningStep);
  877.  
  878.  if(o_DrawAllowed) { 
  879.    o_LearnStepCount++;
  880.  
  881.    if(NewX >= o_OsziWidth) {
  882.      while((NewX >= o_OsziWidth) && (o_XCounter-- > 0)) {
  883.        PixelsOfOneLearningStep = o_XScaleValues[o_XCounter].ScreenEinheit/o_XScaleValues[o_XCounter].Einheit;
  884.        NewX = o_Curve2[o_CurveNo][o_CurveLengths[o_CurveNo]-1].x*PixelsOfOneLearningStep-1;
  885.      } 
  886.      if(NewX >= o_OsziWidth){
  887.        o_DrawAllowed = 0;
  888.      }
  889.      o_XCounter++; 
  890.      o_XBack();
  891.      OldX=o_Curve1[o_CurveNo][(Length-1==-1)?(0):(Length-1)].x;
  892.      NewX =  (OldX+o_PixelsOfOneLearningStep);
  893.    } 
  894.  
  895.    if(o_DrawAllowed) {
  896.      if(o_LearningStepsOfOnePixel == 0) { /* One learning step corresponds with at least one pixel */ 
  897.        error = (int) (o_MaxYDrawPos-(net_error*o_AbsoluteScale));
  898.        if(Length == 0) { /* first time */
  899.          XDrawPoint(o_display,o_Pixmap,o_gc,o_Curve1[o_CurveNo][Length].x=NewX,o_Curve1[o_CurveNo][Length].y=error=(error<0)?(-1):(error));
  900.          XDrawPoint(o_display,o_window,o_gc,NewX+o_SpaceLeft,error+o_SpaceAbove);
  901.        }
  902.        else { /* not first time */
  903.          XDrawLine(o_display,o_Pixmap,o_gc,OldX,OldY,o_Curve1[o_CurveNo][Length].x=NewX,o_Curve1[o_CurveNo][Length].y=error=(error<0)?(-1):(error));
  904.          XDrawLine(o_display,o_window,o_gc,OldX+o_SpaceLeft,OldY+o_SpaceAbove,NewX+o_SpaceLeft,error+o_SpaceAbove);
  905.        }
  906.        o_Curve2[o_CurveNo][Length].x = o_LearnStepCount;
  907.        o_Curve2[o_CurveNo][Length].y = (double)net_error;
  908.        o_CurveLengths[o_CurveNo]++;
  909.      }
  910.      else {  /* One pixel corresponds with more than one learning step */
  911.        if(!(o_LearnStepCount%o_LearningStepsOfOnePixel)) {
  912.          error  = (int) (o_MaxYDrawPos-(net_error*o_AbsoluteScale));
  913.          if(Length == 0) { /* first time */
  914.            XDrawPoint(o_display,o_Pixmap,o_gc,o_Curve1[o_CurveNo][Length].x=NewX,o_Curve1[o_CurveNo][Length].y=error=(error<0)?(-1):(error));
  915.            XDrawPoint(o_display,o_window,o_gc,NewX+o_SpaceLeft,error+o_SpaceAbove);
  916.          }
  917.          else { /* not first time */
  918.            XDrawLine(o_display,o_Pixmap,o_gc,OldX,OldY,o_Curve1[o_CurveNo][Length].x=NewX,o_Curve1[o_CurveNo][Length].y=error=(error<0)?(-1):(error));
  919.            XDrawLine(o_display,o_window,o_gc,OldX+o_SpaceLeft,OldY+o_SpaceAbove,NewX+o_SpaceLeft,error+o_SpaceAbove);
  920.          }
  921.          o_Curve2[o_CurveNo][Length].x = o_LearnStepCount;
  922.          o_Curve2[o_CurveNo][Length].y = (double)net_error;
  923.          o_CurveLengths[o_CurveNo]++;
  924.        }
  925.      }
  926.    }
  927.  }/* if(o_open) */
  928. }
  929.  
  930.  
  931. /*****************************************************************************
  932.   FUNCTION : o_ClearPixmap
  933.  
  934.   PURPOSE  : clears the pixmap
  935.   RETURNS  : void
  936.   NOTES    :
  937.  
  938.   UPDATE   : 3.4.1992
  939. ******************************************************************************/
  940.  
  941. static void o_ClearPixmap (Display *display, Drawable pixmap, GC gc, int screen, 
  942.     int x, int y, int width, int height)
  943.  
  944. {
  945.  XSetForeground (display,gc,WhitePixel(o_display, o_screen));
  946.  XFillRectangle(display,pixmap,gc,x,y,(unsigned int) width,(unsigned int) height);
  947.  XSetForeground(display,gc,BlackPixel(o_display, o_screen));
  948. }
  949.  
  950.  
  951. /*****************************************************************************
  952.   FUNCTION : o_ScaleY
  953.  
  954.   PURPOSE  : draws the y-axis.
  955.   RETURNS  : void
  956.   NOTES    :
  957.  
  958.   UPDATE   : 3.4.1992
  959. ******************************************************************************/
  960.  
  961. static void o_ScaleY (Display *my_display, Drawable my_window, GC my_gc)
  962.  
  963. {
  964.  int buflen;
  965.  char buf[10];
  966.  int count=0;
  967.  int y1,x1,x2,x3;
  968.  int FontWriteYPos = (*o_fontStruct).ascent>>1;
  969.  
  970.  y1 = o_OsziFrameYPos + o_OsziHeight;
  971.  x1 = o_OsziFrameXPos;
  972.  x2 = x1 - 6;
  973.  x3 = x1 - 3; 
  974.  
  975.  while(y1 >= o_OsziFrameYPos) {
  976.      XDrawLine(my_display,my_window,my_gc,x1,y1,x2,y1);   
  977.      sprintf(buf,"%6.2f",(count*(o_YScaleValues[o_YCounter].Einheit)));
  978.      buflen = strlen(buf);
  979.      XDrawString(o_display,o_window,o_gc,
  980.                    x2-XTextWidth(o_fontStruct,buf,buflen),y1+FontWriteYPos,buf,buflen); 
  981.    count++;
  982.    y1 -= o_YScaleValues[o_YCounter].ScreenEinheit;
  983.  }
  984. }
  985.  
  986.  
  987. /*****************************************************************************
  988.   FUNCTION : o_ScaleX
  989.  
  990.   PURPOSE  : draws the x-axix.
  991.   RETURNS  : void
  992.   NOTES    :
  993.  
  994.   UPDATE   : 3.4.1992
  995. ******************************************************************************/
  996.  
  997. static void o_ScaleX (Display *my_display, Drawable my_window, GC my_gc)
  998.  
  999. {
  1000.  int buflen;
  1001.  int count=0;
  1002.  int x1,y1,y2,y3;
  1003.  char buf[10];
  1004.  int o_OsziFrameXPos_AND_o_OsziFrameWidth = o_OsziFrameXPos+o_OsziFrameWidth;
  1005.  int FontWriteXPos = (*o_fontStruct).ascent+2;
  1006.  
  1007.  x1 = o_OsziFrameXPos;
  1008.  y1 = o_OsziFrameYPos+o_OsziHeight;
  1009.  y2 = y1 + 5;
  1010.  y3 = y1 + 2;
  1011.  
  1012.  while(x1 <= o_OsziFrameXPos_AND_o_OsziFrameWidth) {
  1013.      XDrawLine(my_display,my_window,my_gc,x1,y1,x1,y2);
  1014.      sprintf(buf,"%d",(int)(count*o_XScaleValues[o_XCounter].Einheit));
  1015.      buflen = strlen(buf);
  1016.      XDrawString(o_display,o_window,o_gc,
  1017.                    x1-(XTextWidth(o_fontStruct,buf,buflen)>>1)+1,y2+FontWriteXPos,buf,buflen);  
  1018.   x1 += o_XScaleValues[o_XCounter].ScreenEinheit;
  1019.   count++;
  1020.  }
  1021. }
  1022.  
  1023.  
  1024.